package echecs;

import echecs.Pieces.Piece;
import java.util.ArrayList;
import java.util.List;
import static echecs.Pieces.Piece.*;

public class Algorithme extends Etat {

    private List<Coups> listeCoupsPiece;
    private List<Coups> listeCoups;
    private Couleur pCouleurQuiNeJouePas;

    public Algorithme(Couleur pCouleur, Piece[] pPieces, List<Coups> pListeCoups) {
        PIECES = pPieces;
        _couleurQuiJoue = pCouleur;
        while (NewCase.eval()) {
            pPieceDepart = PIECES[pIndexDepart];
            if (PieceCouleurQuiJoue.eval()) {
                listeCoupsPiece = new ArrayList<Coups>();
                listeCoupsPiece = appliquerRegles(pCouleur);
                pListeCoups.addAll(listeCoupsPiece);
            }
            pIndexDepart++;
        }
        listeCoups = pListeCoups;
//        listeCoups = pCouleur == Couleur.BLANC ? eliminerRoiEnEchecs(pListeCoups) : pListeCoups;
    }

    public List<Coups> appliquerRegles(Couleur pCouleur) {
        pDistance = 1;
        pIndexDirection = 0;
        if (EstFouTourOuDame.eval()) {
            while (NewDirection.eval()) {
                while (CaseArriveeVide.eval()) {
                    memoriser();
                    pDistance++;
                }
                if (CaseArriveeOccupee.eval() && PiecesCouleursOpposees.eval()) {
                    memoriser();
                }
                pDistance = 1;
                pIndexDirection++;
            }
        } else if (pPieceDepart.estUnPion()) {
            traiterPion();
        } else {
            pDistance = 1;
            while (NewDirection.eval()) {
                if (CaseArriveeVide.eval() || CaseArriveeOccupee.eval() && PiecesCouleursOpposees.eval()) {
                    memoriser();
                }
                pIndexDirection++;
            }
        }

        pIndexDirection = 0;
        return listeCoupsPiece;
    }

    private void traiterPion() {
        pDistance = 1;
        pIndexDirection = 0;
        if (CaseArriveeVide.eval()) {
            memoriser();
            if (EstUnPionAuDepart.eval()) {
                pDistance = 2;
                if (CaseArriveeVide.eval()) {
                    memoriser();
                }
            }
        }
        for (pIndexDirection = 1; pIndexDirection <= 2; pIndexDirection++) {
            if (CaseArriveeOccupee.eval()) {
                if (PiecesCouleursOpposees.eval()) {
                    memoriser();
                }
            }
        }
    }

    private void memoriser() {
        pIndexArrivee = indexArrivee();
        listeCoupsPiece.add(new Coups(pIndexDepart, pPieceDepart, pIndexArrivee));
    }

    public List<Coups> getListeCoups() {
        return listeCoups;
    }

    private void traiterEnPassant() {
        //TODO
    }

    private void traiterPromotion() {
        //TODO
    }

    private List<Coups> eliminerRoiEnEchecs(List<Coups> pListeCoups) {

        Piece[] copyPIECES;

        int index = 0;
        if (_couleurQuiJoue == Couleur.BLANC) {
            pCouleurQuiNeJouePas = Couleur.NOIR;
            while (PIECES[index] != ROI_BLANC) {
                index++;
            }
        } else {
            pCouleurQuiNeJouePas = Couleur.BLANC;
            index = 0;
            while (PIECES[index] != ROI_NOIR) {
                index++;
            }
        }

//        System.out.print("(ROI en " + Case.valeur(index) + ")");

        for (Coups coups : pListeCoups) {
            copyPIECES = new Piece[NB_COLONNES * NB_RANGEES];
            System.arraycopy(PIECES, 0, copyPIECES, 0, NB_COLONNES * NB_RANGEES);
            copyPIECES = simuler_coups(coups.pIndexDepart, coups.pIndexArrivee, copyPIECES);
           new Algorithme(pCouleurQuiNeJouePas, copyPIECES, new ArrayList<Coups>());


        }
        return pListeCoups;
    }

    private Piece[] simuler_coups(int pIndexDepart, int pIndexArrivee, Piece[] pCopyPIECES) {
        pCopyPIECES[pIndexArrivee] = pCopyPIECES[pIndexDepart];
        pCopyPIECES[pIndexDepart] = null;
        return pCopyPIECES;
    }
}
